/*
 * $Id: ArgumentsTestCase.java 4 2007-12-20 21:20:26Z aaron.day $
 */
package org.crazydays.text;


import java.text.ParseException;

import junit.framework.TestCase;

/**
 * ArgumentsTestCase
 */
public class ArgumentsTestCase
	extends TestCase
{
	/**
	 * Test add argument.
	 */
	public void testAddArgument()
	{
		Arguments arguments = new Arguments();
		assertNotNull("arguments.arguments == null", arguments
				.getArguments());
		assertEquals("arguments.arguments.size != 0", 0, arguments
				.getArguments().size());

		Argument argumentA = new Argument("aaa", 'a', false);
		Argument argumentB = new Argument("bbb", 'b', false);
		Argument argumentC = new Argument("aaa", 'c', false);
		Argument argumentD = new Argument("ddd", 'a', false);
		Argument argumentE = new Argument("aaa", 'a', true);
		Argument argumentF = new Argument("aaa", null, false);
		Argument argumentG = new Argument(null, 'a', false);

		// valid
		try {
			arguments.addArgument(argumentA);
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// valid
		try {
			arguments.addArgument(argumentB);
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// invalid
		try {
			arguments.addArgument(argumentC);
			fail("Expected ArgumentException adding argumentC");
		} catch (ArgumentException e) {
			assertNotNull("e.arguument == null", e.getArgument());
			assertEquals("e.argument != argumentC", argumentC, e
					.getArgument());
		}

		// invalid
		try {
			arguments.addArgument(argumentD);
			fail("Expected ArgumentException adding argumentD");
		} catch (ArgumentException e) {
			assertNotNull("e.arguument == null", e.getArgument());
			assertEquals("e.argument != argumentD", argumentD, e
					.getArgument());
		}

		// invalid
		try {
			arguments.addArgument(argumentE);
			fail("Expected ArgumentException adding argumentE");
		} catch (ArgumentException e) {
			assertNotNull("e.arguument == null", e.getArgument());
			assertEquals("e.argument != argumentE", argumentE, e
					.getArgument());
		}

		// invalid
		try {
			arguments.addArgument(argumentG);
			fail("Expected ArgumentException adding argumentG");
		} catch (ArgumentException e) {
			assertNotNull("e.arguument == null", e.getArgument());
			assertEquals("e.argument != argumentG", argumentG, e
					.getArgument());
		}

		// invalid
		try {
			arguments.addArgument(argumentF);
			fail("Expected ArgumentException adding argumentF");
		} catch (ArgumentException e) {
			assertNotNull("e.arguument == null", e.getArgument());
			assertEquals("e.argument != argumentF", argumentF, e
					.getArgument());
		}
	}

	/**
	 * Test parse.
	 */
	public void testParse()
	{
		Arguments arguments = null;
		Argument argument = null;

		arguments = new Arguments();
		try {
			arguments.addArgument(new Argument("aaa", 'a', false));
			arguments.addArgument(new Argument("bbb", 'b', true));
			arguments.addArgument(new Argument("ccc", 'c', true));
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// empty arguments
		try {
			arguments.parse(new String[] {});
		} catch (ParseException e) {
			fail("ParseException: " + e.getMessage());
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// valid arguments
		try {
			// single string
			arguments.parse(new String[] { "--aaa" });
			argument = arguments.getArgument("aaa");
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != ''", "", argument.getValue());

			arguments.parse(new String[] { "--aaa=xyz" });
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != xyz", "xyz", argument.getValue());

			arguments.parse(new String[] { "--aaa", "xyz" });
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != xyz", "xyz", argument.getValue());

			// single character
			arguments.parse(new String[] { "-a" });
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != ''", "", argument.getValue());

			arguments.parse(new String[] { "-a=xyz" });
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != xyz", "xyz", argument.getValue());

			arguments.parse(new String[] { "-a", "xyz" });
			assertNotNull("argument == null", argument);
			assertEquals("argument.value != xyz", "xyz", argument.getValue());
		} catch (ParseException e) {
			fail("ParseException: " + e.getMessage());
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}


		// invalid: ArgumentException
		String[][] invalidArgumentException =
			new String[][] {
				new String[] { "--xxx" },
				new String[] { "--xxx", "abc" },
				new String[] { "--xxx=abc" },
				new String[] { "-x" },
				new String[] { "-x", "abc" },
				new String[] { "-x=abc" }
			};

		for (int i = 0; i < invalidArgumentException.length; i++) {
			try {
				arguments.parse(invalidArgumentException[i]);
				fail("Expected ArgumentException");
			} catch (ParseException e) {
				fail("ParseException: " + e.getMessage());
			} catch (ArgumentException e) {
				// expect argument exception
			}
		}

		// invalid: ParseException
		String[][] invalidParseException =
			new String[][] {
				new String[] { "" },
				new String[] { "zyx" },
				new String[] { "--aaa=", "xyz" },
				new String[] { "-a=", "xyz" },
				new String[] { "--=" }
			};

		for (int i = 0; i < invalidParseException.length; i++) {
			try {
				arguments.parse(invalidParseException[i]);
				fail("Expected ParseException");
			} catch (ParseException e) {
				// expect parse exception
			} catch (ArgumentException e) {
				fail("ArgumentException: " + e.getMessage());
			}
		}
	}

	/**
	 * Test validate.
	 */
	public void testValidate()
	{
		Arguments arguments = null;

		// setup
		arguments = new Arguments();
		try {
			arguments.addArgument(new Argument("aaa", 'a', false));
			arguments.addArgument(new Argument("bbb", 'b', true));
			arguments.addArgument(new Argument("ccc", 'c', true));
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// valid
		try {
			arguments.parse(new String[] {"-b", "-c"});
			arguments.validate();
			arguments.clearValues();
		} catch (ParseException e) {
			fail("ParseException: " + e.getMessage());
		} catch (ArgumentException e) {
			fail("ArgumentException: " + e.getMessage());
		}

		// invalid
		try {
			arguments.validate();
			fail("Expected ArgumentException");
		} catch (ArgumentException e) {
			assertNotNull("e.argument == null", e.getArgument());
			assertTrue("!e.argument.equals(bbb)", e.getArgument()
					.equals("bbb"));
		}

		// invalid
		try {
			arguments.parse(new String[] { "--ccc" });
			arguments.validate();
			fail("Expected ArgumentException");
		} catch (ParseException e) {
			fail("ParseException: " + e.getMessage());
		} catch (ArgumentException e) {
			assertNotNull("e.argument == null", e.getArgument());
			assertTrue("!e.argument.equals(bbb)", e.getArgument()
					.equals("bbb"));
		}
	}
}
